package fr.miage.orleans.aar.ejb.peupler;

import fr.miage.orleans.aar.ejb.administration.FacadeAdministrationBean;
import fr.miage.orleans.aar.ejb.FacadeBean;
import fr.miage.orleans.aar.ejb.FacadeGettersBean;
import fr.miage.orleans.aar.ejb.FacadeGettersVoBean;
import fr.miage.orleans.aar.ejb.FacadeUtils;
import fr.miage.orleans.aar.modele.Administrateur;
import fr.miage.orleans.aar.modele.Arbitre;
import fr.miage.orleans.aar.modele.But;
import fr.miage.orleans.aar.modele.Equipe;
import fr.miage.orleans.aar.modele.EtatTournoi;
import fr.miage.orleans.aar.modele.Joueur;
import fr.miage.orleans.aar.modele.MatchTour;
import fr.miage.orleans.aar.modele.PosteJoueur;
import fr.miage.orleans.aar.modele.Tournoi;
import java.util.Collection;
import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

/**
 *
 * @author Steve Cancès <steve.cances@gmail.com>
 */
@Stateless
@LocalBean
public class FacadePeuplerBean implements FacadePeuplerLocal {

    @PersistenceContext(unitName = FacadeUtils.PERSISTENCE_CONTEXT_UNIT_NAME)
    private EntityManager entityManager;

    @EJB
    private FacadeBean facade;
    
    @EJB
    private FacadeGettersBean facadeGetters;
    
    @EJB
    private FacadeGettersVoBean facadeGettersVo;

    @EJB
    private FacadeAdministrationBean facadeAdmin;

    public FacadeBean getFacade() {
	return facade;
    }

    public FacadeGettersBean getFacadeGetters() {
	return facadeGetters;
    }

    public FacadeGettersVoBean getFacadeGettersVo() {
	return facadeGettersVo;
    }
    
    public FacadeAdministrationBean getFacadeAdmin()
    {
    	return this.facadeAdmin;
    }

    @Override
    public Collection<Equipe> getEquipesNonInscrites(int tournoiId) {
        return this.facadeGetters.getEquipesNonInscrites(tournoiId);
    }

    @Override
    public Tournoi getTournoiById(int id) {
        return this.facadeGetters.getTournoiById(id);
    }
    
    @Override
    public Tournoi getTournoiDetailById(int id) {
        return this.facadeGetters.getTournoiDetailById(id);
    }
    

    @Override
    public PosteJoueur creerPosteJoueurPourBouchon(String nomPoste) {
        PosteJoueur posteJoueur = null;
        if (nomPoste != null && !nomPoste.isEmpty()) {
            posteJoueur = new PosteJoueur();
            posteJoueur.setNomPoste(nomPoste);
            this.entityManager.persist(posteJoueur);
        }
        return posteJoueur;
    }

    @Override
    public Arbitre createArbitre(String nom, String prenom) {
        return this.facadeAdmin.creerArbitre(nom, prenom);
    }

    @Override
    public Joueur createJoueur(String randomNom, String randomPrenom, PosteJoueur posteJoueur) {
        return this.facade.createJoueur(randomNom, randomPrenom, posteJoueur);
    }

    @Override
    public Equipe createEquipe(String randomNomEquipe) {
        return this.facade.createEquipe(randomNomEquipe);
    }

    @Override
    public Equipe addJoueursToEquipe(Equipe equipe, Collection<Joueur> joueurs) {
        return this.facade.addJoueursToEquipe(equipe, joueurs);
    }

    @Override
    public void inscrireEquipeTournoi(int tournoiId, int equipeId) {
    	this.facade.inscriptionTournoi(equipeId,tournoiId);
    }

    @Override
    public Tournoi creerTournoiPourBouchon(String nomTournoi) {
        Tournoi tournoi = null;
        if (nomTournoi != null && !nomTournoi.isEmpty()) {
            tournoi = new Tournoi();
            tournoi.setNomTournoi(nomTournoi);
            tournoi.setEtatTournoi(EtatTournoi.EN_PREPARATION);
            try {
                this.entityManager.persist(tournoi);
                this.entityManager.flush();
            } catch (Exception ex) {
                tournoi = null;
            }
        }
        return tournoi;
    }
    
    @Override
    public Administrateur createAdmin(String nom, String prenom, String login, String password) {
        Administrateur admininstrateur = new Administrateur();
        admininstrateur.setNom(nom);
        admininstrateur.setPrenom(prenom);
        admininstrateur.setLogin(login);
        admininstrateur.setPassword(password);
        try {
                this.entityManager.persist(admininstrateur);
                this.entityManager.flush();
            } catch (Exception ex) {
                admininstrateur = null;
            }
        
        return admininstrateur;
    }

    @Override
    public boolean validerPreparationTournoi(int tournoiId) {
        return this.facadeAdmin.validerPreparationTournoi(tournoiId);
    }

    @Override
    public But addBut(int idMatch, int idEquipe, int idJoueur, int minute) {
        return this.facadeAdmin.addButMatch(idMatch, idEquipe, idJoueur, minute);
    }
    
    @Override
    public boolean commencerPremiereMiTemps(int idMatch) {
        return this.facadeAdmin.commencerPremiereMiTemps(idMatch);
    }

    @Override
    public void razBdd() {
        try {
            Query qEquipeTournoi = this.entityManager.createQuery("DELETE FROM EquipeTournoi t");
            Query qBut = this.entityManager.createQuery("DELETE FROM But b");
            Query qMatchTour = this.entityManager.createQuery("DELETE FROM MatchTour m");
            Query qTournoi = this.entityManager.createQuery("DELETE FROM Tournoi t");
            Query qJoueur = this.entityManager.createQuery("DELETE FROM Joueur j");
            //Query qArbitre = this.entityManager.createQuery("DELETE FROM Arbitre a");
            Query qPersonne = this.entityManager.createQuery("DELETE FROM Personne p WHERE p.personneId NOT IN (SELECT a.personneId FROM Administrateur a) AND p.personneId NOT IN (SELECT aa.personneId FROM Arbitre aa)");
            Query qEquipe = this.entityManager.createQuery("DELETE FROM Equipe e");
            

            qEquipeTournoi.executeUpdate();
            qBut.executeUpdate();
            qMatchTour.executeUpdate();
            qTournoi.executeUpdate();
            qJoueur.executeUpdate();
            //qArbitre.executeUpdate();
            qPersonne.executeUpdate();
            qEquipe.executeUpdate();
            
        } catch (Exception ex) {

        }
    }
    
    @Override
    public Collection<Arbitre> getAllArbitres() {
        return this.facadeAdmin.getAllArbitres();
    }
    
    @Override
    public MatchTour affecterArbitreMatch(int idMatch, int idArbitre) {
        return this.facadeAdmin.affecterArbitreMatch(idMatch, idArbitre);
    }
}
